{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to create branches for parallel node execution\n",
    "\n",
    "LangGraph4j lets you run nodes in parallel to speed up your total graph execution.\n",
    "\n",
    "Currently there are some limitations on parallel execution:\n",
    "\n",
    " \n",
    "* Only the **Fork-Join** model is supported\n",
    " \n",
    "  > ```\n",
    "  >        ┌─┐       \n",
    "  >        │A│       \n",
    "  >        └─┘       \n",
    "  >         |        \n",
    "  >   ┌-----------┐  \n",
    "  >   |     |     |  \n",
    "  > ┌──┐  ┌──┐  ┌──┐ \n",
    "  > │A1│  │A2│  │A3│ \n",
    "  > └──┘  └──┘  └──┘ \n",
    "  >   |     |     |  \n",
    "  >   └-----------┘  \n",
    "  >         |        \n",
    "  >        ┌─┐       \n",
    "  >        │B│       \n",
    "  >        └─┘       \n",
    "  >   ```\n",
    "* No **Conditional Edges** are allowed\n",
    "  \n",
    "Below are some examples showing how to add create branching dataflows that work for you.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "var userHomeDir = System.getProperty(\"user.home\");\n",
    "var localRespoUrl = \"file://\" + userHomeDir + \"/.m2/repository/\";\n",
    "var langchain4jVersion = \"0.36.2\";\n",
    "var langgraph4jVersion = \"1.4-SNAPSHOT\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash \n",
    "rm -rf \\{userHomeDir}/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/bsc/langgraph4j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0mRepository \u001b[1m\u001b[32mlocal\u001b[0m url: \u001b[1m\u001b[32mfile:///Users/bsorrentino/.m2/repository/\u001b[0m added.\n",
      "\u001b[0mAdding dependency \u001b[0m\u001b[1m\u001b[32morg.slf4j:slf4j-jdk14:2.0.9\n",
      "\u001b[0mAdding dependency \u001b[0m\u001b[1m\u001b[32morg.bsc.langgraph4j:langgraph4j-core:1.3-SNAPSHOT\n",
      "\u001b[0mAdding dependency \u001b[0m\u001b[1m\u001b[32morg.bsc.langgraph4j:langgraph4j-langchain4j:1.3-SNAPSHOT\n",
      "\u001b[0mAdding dependency \u001b[0m\u001b[1m\u001b[32mdev.langchain4j:langchain4j:0.36.2\n",
      "\u001b[0mAdding dependency \u001b[0m\u001b[1m\u001b[32mdev.langchain4j:langchain4j-open-ai:0.36.2\n",
      "\u001b[0mAdding dependency \u001b[0m\u001b[1m\u001b[32mnet.sourceforge.plantuml:plantuml-mit:1.2024.8\n",
      "\u001b[0mSolving dependencies\n",
      "Resolved artifacts count: 27\n",
      "Add to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/slf4j/slf4j-jdk14/2.0.9/slf4j-jdk14-2.0.9.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/slf4j/slf4j-api/2.0.9/slf4j-api-2.0.9.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/bsc/langgraph4j/langgraph4j-core/1.3-SNAPSHOT/langgraph4j-core-1.3-SNAPSHOT.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/bsc/async/async-generator/3.0.0/async-generator-3.0.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/bsc/langgraph4j/langgraph4j-langchain4j/1.3-SNAPSHOT/langgraph4j-langchain4j-1.3-SNAPSHOT.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/dev/langchain4j/langchain4j/0.36.2/langchain4j-0.36.2.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/dev/langchain4j/langchain4j-core/0.36.2/langchain4j-core-0.36.2.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/google/code/gson/gson/2.10.1/gson-2.10.1.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/apache/opennlp/opennlp-tools/1.9.4/opennlp-tools-1.9.4.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/dev/langchain4j/langchain4j-open-ai/0.36.2/langchain4j-open-ai-0.36.2.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/dev/ai4j/openai4j/0.23.0/openai4j-0.23.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/squareup/retrofit2/retrofit/2.9.0/retrofit-2.9.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/squareup/retrofit2/converter-jackson/2.9.0/converter-jackson-2.9.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/fasterxml/jackson/core/jackson-databind/2.17.2/jackson-databind-2.17.2.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/fasterxml/jackson/core/jackson-annotations/2.17.2/jackson-annotations-2.17.2.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/fasterxml/jackson/core/jackson-core/2.17.2/jackson-core-2.17.2.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/squareup/okhttp3/okhttp/4.12.0/okhttp-4.12.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/squareup/okio/okio/3.6.0/okio-3.6.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/squareup/okio/okio-jvm/3.6.0/okio-jvm-3.6.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/jetbrains/kotlin/kotlin-stdlib-common/1.9.10/kotlin-stdlib-common-1.9.10.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/squareup/okhttp3/okhttp-sse/4.12.0/okhttp-sse-4.12.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.25/kotlin-stdlib-jdk8-1.9.25.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/jetbrains/kotlin/kotlin-stdlib/1.9.25/kotlin-stdlib-1.9.25.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/jetbrains/annotations/13.0/annotations-13.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.9.25/kotlin-stdlib-jdk7-1.9.25.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/com/knuddels/jtokkit/1.1.0/jtokkit-1.1.0.jar\u001b[0m\n",
      "\u001b[0mAdd to classpath: \u001b[0m\u001b[32m/Users/bsorrentino/Library/Jupyter/kernels/rapaio-jupyter-kernel/mima_cache/net/sourceforge/plantuml/plantuml-mit/1.2024.8/plantuml-mit-1.2024.8.jar\u001b[0m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "%dependency /add-repo local \\{localRespoUrl} release|never snapshot|always\n",
    "// %dependency /list-repos\n",
    "%dependency /add org.slf4j:slf4j-jdk14:2.0.9\n",
    "%dependency /add org.bsc.langgraph4j:langgraph4j-core:\\{langgraph4jVersion}\n",
    "%dependency /add org.bsc.langgraph4j:langgraph4j-langchain4j:\\{langgraph4jVersion}\n",
    "%dependency /add dev.langchain4j:langchain4j:\\{langchain4jVersion}\n",
    "%dependency /add dev.langchain4j:langchain4j-open-ai:\\{langchain4jVersion}\n",
    "%dependency /add net.sourceforge.plantuml:plantuml-mit:1.2024.8\n",
    "\n",
    "%dependency /resolve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "try( var file = new java.io.FileInputStream(\"./logging.properties\")) {\n",
    "    var lm = java.util.logging.LogManager.getLogManager();\n",
    "    lm.checkAccess(); \n",
    "    lm.readConfiguration( file );\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import net.sourceforge.plantuml.SourceStringReader;\n",
    "import net.sourceforge.plantuml.FileFormatOption;\n",
    "import net.sourceforge.plantuml.FileFormat;\n",
    "\n",
    "java.awt.Image plantUML2PNG( String code ) throws IOException { \n",
    "    var reader = new SourceStringReader(code);\n",
    "\n",
    "    try(var imageOutStream = new java.io.ByteArrayOutputStream()) {\n",
    "\n",
    "        var description = reader.outputImage( imageOutStream, 0, new FileFormatOption(FileFormat.PNG));\n",
    "\n",
    "        var imageInStream = new java.io.ByteArrayInputStream(  imageOutStream.toByteArray() );\n",
    "\n",
    "        return javax.imageio.ImageIO.read( imageInStream );\n",
    "\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Graph with parallel branch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import org.bsc.langgraph4j.prebuilt.MessagesStateGraph;\n",
    "import org.bsc.langgraph4j.prebuilt.MessagesState;\n",
    "import org.bsc.langgraph4j.action.AsyncNodeAction;\n",
    "import static org.bsc.langgraph4j.action.AsyncNodeAction.node_async;\n",
    "import static org.bsc.langgraph4j.StateGraph.END;\n",
    "import static org.bsc.langgraph4j.StateGraph.START;\n",
    "\n",
    "AsyncNodeAction<MessagesState<String>> makeNode( String message ) {\n",
    "    return node_async(state -> Map.of( \"messages\", message ) );\n",
    "}\n",
    "\n",
    "var workflow = new MessagesStateGraph<String>()\n",
    "                .addNode(\"A\", makeNode(\"A\"))\n",
    "                .addNode(\"A1\", makeNode(\"A1\"))\n",
    "                .addNode(\"A2\", makeNode(\"A2\"))\n",
    "                .addNode(\"A3\", makeNode(\"A3\"))\n",
    "                .addNode(\"B\", makeNode(\"B\"))\n",
    "                .addNode(\"C\", makeNode(\"C\"))\n",
    "                .addEdge(\"A\", \"A1\")\n",
    "                .addEdge(\"A\", \"A2\")\n",
    "                .addEdge(\"A\", \"A3\")\n",
    "                .addEdge(\"A1\", \"B\")\n",
    "                .addEdge(\"A2\", \"B\")\n",
    "                .addEdge(\"A3\", \"B\")\n",
    "                .addEdge(\"B\", \"C\")\n",
    "                .addEdge(START, \"A\")\n",
    "                .addEdge(\"C\", END)                   \n",
    "                .compile();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print graph representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "e8b0658e-a244-4dc5-9869-481f21b5b77a"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import org.bsc.langgraph4j.GraphRepresentation;\n",
    "\n",
    "var representation = workflow.getGraph( GraphRepresentation.Type.PLANTUML, \"parallel branch\",false );\n",
    "\n",
    "display( plantUML2PNG( representation.getContent() ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "START \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NodeOutput{node=__START__, state={messages=[]}}\n",
      "NodeOutput{node=A, state={messages=[A]}}\n",
      "NodeOutput{node=__PARALLEL__(A), state={messages=[A, A1, A2, A3]}}\n",
      "NodeOutput{node=B, state={messages=[A, A1, A2, A3, B]}}\n",
      "NodeOutput{node=C, state={messages=[A, A1, A2, A3, B, C]}}\n",
      "NodeOutput{node=__END__, state={messages=[A, A1, A2, A3, B, C]}}\n"
     ]
    }
   ],
   "source": [
    "for( var step : workflow.stream( Map.of() ) ) {\n",
    "    System.out.println( step );\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import org.bsc.langgraph4j.prebuilt.MessagesStateGraph;\n",
    "import org.bsc.langgraph4j.prebuilt.MessagesState;\n",
    "import org.bsc.langgraph4j.action.AsyncNodeAction;\n",
    "import static org.bsc.langgraph4j.action.AsyncNodeAction.node_async;\n",
    "import static org.bsc.langgraph4j.action.AsyncEdgeAction.edge_async;\n",
    "import static org.bsc.langgraph4j.StateGraph.END;\n",
    "import static org.bsc.langgraph4j.StateGraph.START;\n",
    "\n",
    "AsyncNodeAction<MessagesState<String>> makeNode( String message ) {\n",
    "    return node_async(state -> Map.of( \"messages\", message ) );\n",
    "}\n",
    "\n",
    "var workflow = new MessagesStateGraph<String>()\n",
    "                .addNode(\"A\", makeNode(\"A\"))\n",
    "                .addNode(\"A1\", makeNode(\"A1\"))\n",
    "                .addNode(\"A2\", makeNode(\"A2\"))\n",
    "                .addNode(\"A3\", makeNode(\"A3\"))\n",
    "                .addNode(\"B\", makeNode(\"B\"))\n",
    "                .addNode(\"C\", makeNode(\"C\"))\n",
    "                .addEdge(\"A\", \"A1\")\n",
    "                .addEdge(\"A\", \"A2\")\n",
    "                .addEdge(\"A\", \"A3\")\n",
    "                .addEdge(\"A1\", \"B\")\n",
    "                .addEdge(\"A2\", \"B\")\n",
    "                .addEdge(\"A3\", \"B\")\n",
    "                // .addEdge(\"B\", \"C\")\n",
    "                .addConditionalEdges( \"B\", \n",
    "                    edge_async( state -> \n",
    "                        state.lastMinus(1) \n",
    "                            .filter( m -> Objects.equals(m,\"A1\"))\n",
    "                            .map( m -> \"continue\" )\n",
    "                            .orElse(\"back\") ), \n",
    "                    Map.of( \"back\", \"A1\", \"continue\", \"C\")\n",
    "                 )\n",
    "                .addEdge(START, \"A\")\n",
    "                .addEdge(\"C\", END)                   \n",
    "                .compile();\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "73f4846d-1a37-479e-8e93-d997c30f4bdb"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import org.bsc.langgraph4j.GraphRepresentation;\n",
    "\n",
    "var representation = workflow.getGraph( GraphRepresentation.Type.PLANTUML, \"parallel branch\",false );\n",
    "\n",
    "display( plantUML2PNG( representation.getContent() ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "START \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NodeOutput{node=__START__, state={messages=[]}}\n",
      "NodeOutput{node=A, state={messages=[A]}}\n",
      "NodeOutput{node=__PARALLEL__(A), state={messages=[A, A1, A2, A3]}}\n",
      "NodeOutput{node=B, state={messages=[A, A1, A2, A3, B]}}\n",
      "NodeOutput{node=A1, state={messages=[A, A1, A2, A3, B, A1]}}\n",
      "NodeOutput{node=B, state={messages=[A, A1, A2, A3, B, A1, B]}}\n",
      "NodeOutput{node=C, state={messages=[A, A1, A2, A3, B, A1, B, C]}}\n",
      "NodeOutput{node=__END__, state={messages=[A, A1, A2, A3, B, A1, B, C]}}\n"
     ]
    }
   ],
   "source": [
    "for( var step : workflow.stream( Map.of() ) ) {\n",
    "    System.out.println( step );\n",
    "}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java (rjk 2.2.0)",
   "language": "java",
   "name": "rapaio-jupyter-kernel"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "java",
   "nbconvert_exporter": "script",
   "pygments_lexer": "java",
   "version": "17.0.2+8-86"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
